University of Delaware Department of Electrical and Computer Engineering Computer Architecture and Parallel Systems Laboratory Executable Performance Model and Evaluation of High Performance Architectures with Percolation

Percolation has recently been proposed as a key component of an advanced program execution model for future generation high-end machines featuring adaptive data/code transformation and movement for effective latency tolerance. Percolation is related to conventional prefetch technique, but is more aggressive and smarter. A program unit (e.g. a procedure instance) is not ready to be scheduled for execution until the data it needs is in the right place (close to the code in the memory hierarchy) and in the right form (e.g. proper layout, etc.). Supporting percolation is a major effort in the architecture design and the compiler/runtime software support. An early evaluation of the performance effect of percolation is very important in the design space exploration of future generations of supercomputers. However, performance evaluation of percolation using a traditional approach for computer architecture (e.g. execution-driven or trace-driven simulation) is both time consuming and impractical. Further, in early-stage architecture design/performance evaluation which deals with incomplete design details, or a program execution model with only a (sketchy) conceptual design, or an architecture without an (optimizing) compiler, make simulation-based approaches unsuitable. In this paper, we develop an executable analytical performance model of a high performance multithreaded architecture that supports percolation. A novel feature of our approach is that it models the interaction between the software (program) and hardware (architecture) components. We solve the analytical model using a queuing simulation tool enriched with synchronization. The proposed approach is effective and facilitates obtaining performance trends quickly. Our results indicate that percolation brings in significant performance gains (by a factor of 2.7 to 11) when memory latency ranges from local memory access time to remote memory access time (in a multiprocessor system). Further, our results reveal that percolation and multithreading can complement each other and can work together to tolerate memory latency, especially in a multiprocessor system.